home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / shells / scsh-0.4 / scsh-0 / scsh-0.4.2 / scsh / syscalls.c < prev    next >
C/C++ Source or Header  |  1995-11-04  |  30KB  |  1,177 lines
  1. /* This is an Scheme48/C interface file, 
  2. ** automatically generated by cig.
  3. */
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h> /* For malloc. */
  7. #include "libcig.h"
  8.  
  9. #include <sys/signal.h>
  10. #include <sys/types.h>
  11. #include <sys/times.h>
  12. #include <sys/time.h>
  13. #include <fcntl.h>        /* for O_RDWR */
  14. #include <sys/stat.h>
  15. #include <netdb.h>
  16. #include <pwd.h>
  17. #include <unistd.h>
  18.  
  19. /* Make sure foreign-function stubs interface to the C funs correctly: */
  20. #include "dirstuff1.h"
  21. #include "fdports1.h"
  22. #include "select1.h"
  23. #include "syscalls1.h"
  24. #include "userinfo1.h"
  25.  
  26. extern int errno;
  27.  
  28. #define errno_on_zero_or_false(x) ((x) ? SCHFALSE : ENTER_FIXNUM(errno))
  29. #define errno_or_false(x) (((x) == -1) ? ENTER_FIXNUM(errno) : SCHFALSE)
  30. #define False_on_zero(x) ((x) ? ENTER_FIXNUM(x) : SCHFALSE)
  31.  
  32. scheme_value df_scheme_exec(long nargs, scheme_value *args)
  33. {
  34.     extern int scheme_exec(const char *, scheme_value , scheme_value );
  35.     scheme_value ret1;
  36.     int r1;
  37.  
  38.     cig_check_nargs(3, nargs, "scheme_exec");
  39.     r1 = scheme_exec(cig_string_body(args[2]), args[1], args[0]);
  40.     ret1 = ENTER_FIXNUM(r1);
  41.     return ret1;
  42.     }
  43.  
  44. scheme_value df_exit(long nargs, scheme_value *args)
  45. {
  46.     extern void exit(int );
  47.  
  48.     cig_check_nargs(1, nargs, "exit");
  49.     exit(EXTRACT_FIXNUM(args[0]));
  50.     return SCHFALSE;
  51.     }
  52.  
  53. scheme_value df__exit(long nargs, scheme_value *args)
  54. {
  55.     extern void _exit(int );
  56.  
  57.     cig_check_nargs(1, nargs, "_exit");
  58.     _exit(EXTRACT_FIXNUM(args[0]));
  59.     return SCHFALSE;
  60.     }
  61.  
  62. scheme_value df_fork(long nargs, scheme_value *args)
  63. {
  64.     extern pid_t fork(void);
  65.     scheme_value ret1;
  66.     pid_t r1;
  67.  
  68.     cig_check_nargs(1, nargs, "fork");
  69.     r1 = fork();
  70.     ret1 = errno_or_false(r1);
  71.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  72.     return ret1;
  73.     }
  74.  
  75. scheme_value df_wait_pid(long nargs, scheme_value *args)
  76. {
  77.     extern scheme_value wait_pid(int , int , int *, int *);
  78.     scheme_value ret1;
  79.     scheme_value r1;
  80.     int r2;
  81.     int r3;
  82.  
  83.     cig_check_nargs(3, nargs, "wait_pid");
  84.     r1 = wait_pid(EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]), &r2, &r3);
  85.     ret1 = r1;
  86.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r2);
  87.     VECTOR_REF(*args,1) = ENTER_FIXNUM(r3);
  88.     return ret1;
  89.     }
  90.  
  91. scheme_value df_chdir(long nargs, scheme_value *args)
  92. {
  93.     extern int chdir(const char *);
  94.     scheme_value ret1;
  95.     int r1;
  96.  
  97.     cig_check_nargs(1, nargs, "chdir");
  98.     r1 = chdir(cig_string_body(args[0]));
  99.     ret1 = errno_or_false(r1);
  100.     return ret1;
  101.     }
  102.  
  103. scheme_value df_scheme_cwd(long nargs, scheme_value *args)
  104. {
  105.     extern int scheme_cwd(const char **);
  106.     scheme_value ret1;
  107.     int r1;
  108.     const char *r2;
  109.  
  110.     cig_check_nargs(1, nargs, "scheme_cwd");
  111.     r1 = scheme_cwd(&r2);
  112.     ret1 = False_on_zero(r1);
  113.     {AlienVal(CAR(VECTOR_REF(*args,0))) = (long) r2; CDR(VECTOR_REF(*args,0)) = strlen_or_false(r2);}
  114.     return ret1;
  115.     }
  116.  
  117. scheme_value df_getgid(long nargs, scheme_value *args)
  118. {
  119.     extern gid_t  getgid(void);
  120.     scheme_value ret1;
  121.     gid_t  r1;
  122.  
  123.     cig_check_nargs(0, nargs, "getgid");
  124.     r1 = getgid();
  125.     ret1 = ENTER_FIXNUM(r1);
  126.     return ret1;
  127.     }
  128.  
  129. scheme_value df_getegid(long nargs, scheme_value *args)
  130. {
  131.     extern gid_t  getegid(void);
  132.     scheme_value ret1;
  133.     gid_t  r1;
  134.  
  135.     cig_check_nargs(0, nargs, "getegid");
  136.     r1 = getegid();
  137.     ret1 = ENTER_FIXNUM(r1);
  138.     return ret1;
  139.     }
  140.  
  141. scheme_value df_setgid(long nargs, scheme_value *args)
  142. {
  143.     extern int setgid(gid_t  );
  144.     scheme_value ret1;
  145.     int r1;
  146.  
  147.     cig_check_nargs(1, nargs, "setgid");
  148.     r1 = setgid(EXTRACT_FIXNUM(args[0]));
  149.     ret1 = errno_or_false(r1);
  150.     return ret1;
  151.     }
  152.  
  153. scheme_value df_num_supp_groups(long nargs, scheme_value *args)
  154. {
  155.     extern int num_supp_groups(void);
  156.     scheme_value ret1;
  157.     int r1;
  158.  
  159.     cig_check_nargs(1, nargs, "num_supp_groups");
  160.     r1 = num_supp_groups();
  161.     ret1 = errno_or_false(r1);
  162.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  163.     return ret1;
  164.     }
  165.  
  166. scheme_value df_get_groups(long nargs, scheme_value *args)
  167. {
  168.     extern int get_groups(scheme_value );
  169.     scheme_value ret1;
  170.     int r1;
  171.  
  172.     cig_check_nargs(2, nargs, "get_groups");
  173.     r1 = get_groups(args[1]);
  174.     ret1 = errno_or_false(r1);
  175.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  176.     return ret1;
  177.     }
  178.  
  179. scheme_value df_getuid(long nargs, scheme_value *args)
  180. {
  181.     extern uid_t getuid(void);
  182.     scheme_value ret1;
  183.     uid_t r1;
  184.  
  185.     cig_check_nargs(0, nargs, "getuid");
  186.     r1 = getuid();
  187.     ret1 = ENTER_FIXNUM(r1);
  188.     return ret1;
  189.     }
  190.  
  191. scheme_value df_geteuid(long nargs, scheme_value *args)
  192. {
  193.     extern uid_t geteuid(void);
  194.     scheme_value ret1;
  195.     uid_t r1;
  196.  
  197.     cig_check_nargs(0, nargs, "geteuid");
  198.     r1 = geteuid();
  199.     ret1 = ENTER_FIXNUM(r1);
  200.     return ret1;
  201.     }
  202.  
  203. scheme_value df_setuid(long nargs, scheme_value *args)
  204. {
  205.     extern int setuid(uid_t );
  206.     scheme_value ret1;
  207.     int r1;
  208.  
  209.     cig_check_nargs(1, nargs, "setuid");
  210.     r1 = setuid(EXTRACT_FIXNUM(args[0]));
  211.     ret1 = errno_or_false(r1);
  212.     return ret1;
  213.     }
  214.  
  215. scheme_value df_my_username(long nargs, scheme_value *args)
  216. {
  217.     extern char *my_username(void);
  218.     scheme_value ret1;
  219.     char *r1;
  220.  
  221.     cig_check_nargs(1, nargs, "my_username");
  222.     r1 = my_username();
  223.     ret1 = VECTOR_REF(*args,0);
  224.     {AlienVal(CAR(ret1)) = (long) r1; CDR(ret1) = strlen_or_false(r1);}
  225.     return ret1;
  226.     }
  227.  
  228. scheme_value df_getpid(long nargs, scheme_value *args)
  229. {
  230.     extern pid_t getpid(void);
  231.     scheme_value ret1;
  232.     pid_t r1;
  233.  
  234.     cig_check_nargs(0, nargs, "getpid");
  235.     r1 = getpid();
  236.     ret1 = ENTER_FIXNUM(r1);
  237.     return ret1;
  238.     }
  239.  
  240. scheme_value df_getppid(long nargs, scheme_value *args)
  241. {
  242.     extern pid_t getppid(void);
  243.     scheme_value ret1;
  244.     pid_t r1;
  245.  
  246.     cig_check_nargs(0, nargs, "getppid");
  247.     r1 = getppid();
  248.     ret1 = ENTER_FIXNUM(r1);
  249.     return ret1;
  250.     }
  251.  
  252. scheme_value df_getpgrp(long nargs, scheme_value *args)
  253. {
  254.     extern pid_t getpgrp(void);
  255.     scheme_value ret1;
  256.     pid_t r1;
  257.  
  258.     cig_check_nargs(0, nargs, "getpgrp");
  259.     r1 = getpgrp();
  260.     ret1 = ENTER_FIXNUM(r1);
  261.     return ret1;
  262.     }
  263.  
  264. scheme_value df_setpgid(long nargs, scheme_value *args)
  265. {
  266.     extern int setpgid(pid_t , pid_t );
  267.     scheme_value ret1;
  268.     int r1;
  269.  
  270.     cig_check_nargs(2, nargs, "setpgid");
  271.     r1 = setpgid(EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  272.     ret1 = errno_or_false(r1);
  273.     return ret1;
  274.     }
  275.  
  276. scheme_value df_setsid(long nargs, scheme_value *args)
  277. {
  278.     extern pid_t setsid(void);
  279.     scheme_value ret1;
  280.     pid_t r1;
  281.  
  282.     cig_check_nargs(1, nargs, "setsid");
  283.     r1 = setsid();
  284.     ret1 = errno_or_false(r1);
  285.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  286.     return ret1;
  287.     }
  288.  
  289. scheme_value df_umask(long nargs, scheme_value *args)
  290. {
  291.     
  292.     scheme_value ret1;
  293.     mode_t r1;
  294.  
  295.     cig_check_nargs(1, nargs, "umask");
  296.     r1 = umask(EXTRACT_FIXNUM(args[0]));
  297.     ret1 = ENTER_FIXNUM(r1);
  298.     return ret1;
  299.     }
  300.  
  301. scheme_value df_process_times(long nargs, scheme_value *args)
  302. {
  303.     extern int process_times(int *, int *, int *, int *);
  304.     scheme_value ret1;
  305.     int r1;
  306.     int r2;
  307.     int r3;
  308.     int r4;
  309.     int r5;
  310.  
  311.     cig_check_nargs(1, nargs, "process_times");
  312.     r1 = process_times(&r2, &r3, &r4, &r5);
  313.     ret1 = errno_or_false(r1);
  314.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r2);
  315.     VECTOR_REF(*args,1) = ENTER_FIXNUM(r3);
  316.     VECTOR_REF(*args,2) = ENTER_FIXNUM(r4);
  317.     VECTOR_REF(*args,3) = ENTER_FIXNUM(r5);
  318.     return ret1;
  319.     }
  320.  
  321. scheme_value df_cpu_clock_ticks_per_sec(long nargs, scheme_value *args)
  322. {
  323.     extern int cpu_clock_ticks_per_sec(void);
  324.     scheme_value ret1;
  325.     int r1;
  326.  
  327.     cig_check_nargs(0, nargs, "cpu_clock_ticks_per_sec");
  328.     r1 = cpu_clock_ticks_per_sec();
  329.     ret1 = ENTER_FIXNUM(r1);
  330.     return ret1;
  331.     }
  332.  
  333. scheme_value df_chmod(long nargs, scheme_value *args)
  334. {
  335.     
  336.     scheme_value ret1;
  337.     int r1;
  338.  
  339.     cig_check_nargs(2, nargs, "chmod");
  340.     r1 = chmod(cig_string_body(args[1]), EXTRACT_FIXNUM(args[0]));
  341.     ret1 = errno_or_false(r1);
  342.     return ret1;
  343.     }
  344.  
  345. scheme_value df_fchmod(long nargs, scheme_value *args)
  346. {
  347.     
  348.     scheme_value ret1;
  349.     int r1;
  350.  
  351.     cig_check_nargs(2, nargs, "fchmod");
  352.     r1 = fchmod(EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  353.     ret1 = errno_or_false(r1);
  354.     return ret1;
  355.     }
  356.  
  357. scheme_value df_chown(long nargs, scheme_value *args)
  358. {
  359.     
  360.     scheme_value ret1;
  361.     int r1;
  362.  
  363.     cig_check_nargs(3, nargs, "chown");
  364.     r1 = chown(cig_string_body(args[2]), EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  365.     ret1 = errno_or_false(r1);
  366.     return ret1;
  367.     }
  368.  
  369. scheme_value df_fchown(long nargs, scheme_value *args)
  370. {
  371.     extern int fchown(int , uid_t , gid_t  );
  372.     scheme_value ret1;
  373.     int r1;
  374.  
  375.     cig_check_nargs(3, nargs, "fchown");
  376.     r1 = fchown(EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  377.     ret1 = errno_or_false(r1);
  378.     return ret1;
  379.     }
  380.  
  381. scheme_value df_access(long nargs, scheme_value *args)
  382. {
  383.     extern int access(const char *, int );
  384.     scheme_value ret1;
  385.     int r1;
  386.  
  387.     cig_check_nargs(2, nargs, "access");
  388.     r1 = access(cig_string_body(args[1]), EXTRACT_FIXNUM(args[0]));
  389.     ret1 = ENTER_BOOLEAN(r1);
  390.     return ret1;
  391.     }
  392.  
  393. scheme_value df_link(long nargs, scheme_value *args)
  394. {
  395.     extern int link(const char *, const char *);
  396.     scheme_value ret1;
  397.     int r1;
  398.  
  399.     cig_check_nargs(2, nargs, "link");
  400.     r1 = link(cig_string_body(args[1]), cig_string_body(args[0]));
  401.     ret1 = errno_or_false(r1);
  402.     return ret1;
  403.     }
  404.  
  405. scheme_value df_mkfifo(long nargs, scheme_value *args)
  406. {
  407.     
  408.     scheme_value ret1;
  409.     int r1;
  410.  
  411.     cig_check_nargs(2, nargs, "mkfifo");
  412.     r1 = mkfifo(cig_string_body(args[1]), EXTRACT_FIXNUM(args[0]));
  413.     ret1 = errno_or_false(r1);
  414.     return ret1;
  415.     }
  416.  
  417. scheme_value df_mkdir(long nargs, scheme_value *args)
  418. {
  419.     
  420.     scheme_value ret1;
  421.     int r1;
  422.  
  423.     cig_check_nargs(2, nargs, "mkdir");
  424.     r1 = mkdir(cig_string_body(args[1]), EXTRACT_FIXNUM(args[0]));
  425.     ret1 = errno_or_false(r1);
  426.     return ret1;
  427.     }
  428.  
  429. scheme_value df_scm_readlink(long nargs, scheme_value *args)
  430. {
  431.     extern const char *scm_readlink(const char *);
  432.     scheme_value ret1;
  433.     const char *r1;
  434.  
  435.     cig_check_nargs(2, nargs, "scm_readlink");
  436.     r1 = scm_readlink(cig_string_body(args[1]));
  437.     ret1 = errno_on_zero_or_false(r1);
  438.     {AlienVal(CAR(VECTOR_REF(*args,0))) = (long) r1; CDR(VECTOR_REF(*args,0)) = strlen_or_false(r1);}
  439.     return ret1;
  440.     }
  441.  
  442. scheme_value df_rename(long nargs, scheme_value *args)
  443. {
  444.     extern int rename(const char *, const char *);
  445.     scheme_value ret1;
  446.     int r1;
  447.  
  448.     cig_check_nargs(2, nargs, "rename");
  449.     r1 = rename(cig_string_body(args[1]), cig_string_body(args[0]));
  450.     ret1 = errno_or_false(r1);
  451.     return ret1;
  452.     }
  453.  
  454. scheme_value df_rmdir(long nargs, scheme_value *args)
  455. {
  456.     extern int rmdir(const char *);
  457.     scheme_value ret1;
  458.     int r1;
  459.  
  460.     cig_check_nargs(1, nargs, "rmdir");
  461.     r1 = rmdir(cig_string_body(args[0]));
  462.     ret1 = errno_or_false(r1);
  463.     return ret1;
  464.     }
  465.  
  466. scheme_value df_scm_utime(long nargs, scheme_value *args)
  467. {
  468.     extern int scm_utime(const char *, int , int , int , int );
  469.     scheme_value ret1;
  470.     int r1;
  471.  
  472.     cig_check_nargs(5, nargs, "scm_utime");
  473.     r1 = scm_utime(cig_string_body(args[4]), EXTRACT_FIXNUM(args[3]), EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  474.     ret1 = errno_or_false(r1);
  475.     return ret1;
  476.     }
  477.  
  478. scheme_value df_scm_utime_now(long nargs, scheme_value *args)
  479. {
  480.     extern int scm_utime_now(const char *);
  481.     scheme_value ret1;
  482.     int r1;
  483.  
  484.     cig_check_nargs(1, nargs, "scm_utime_now");
  485.     r1 = scm_utime_now(cig_string_body(args[0]));
  486.     ret1 = errno_or_false(r1);
  487.     return ret1;
  488.     }
  489.  
  490. scheme_value df_scheme_stat(long nargs, scheme_value *args)
  491. {
  492.     extern int scheme_stat(const char *, scheme_value , int );
  493.     scheme_value ret1;
  494.     int r1;
  495.  
  496.     cig_check_nargs(3, nargs, "scheme_stat");
  497.     r1 = scheme_stat(cig_string_body(args[2]), args[1], EXTRACT_BOOLEAN(args[0]));
  498.     ret1 = False_on_zero(r1);
  499.     return ret1;
  500.     }
  501.  
  502. scheme_value df_scheme_fstat(long nargs, scheme_value *args)
  503. {
  504.     extern int scheme_fstat(int , scheme_value );
  505.     scheme_value ret1;
  506.     int r1;
  507.  
  508.     cig_check_nargs(2, nargs, "scheme_fstat");
  509.     r1 = scheme_fstat(EXTRACT_FIXNUM(args[1]), args[0]);
  510.     ret1 = False_on_zero(r1);
  511.     return ret1;
  512.     }
  513.  
  514. scheme_value df_symlink(long nargs, scheme_value *args)
  515. {
  516.     
  517.     scheme_value ret1;
  518.     int r1;
  519.  
  520.     cig_check_nargs(2, nargs, "symlink");
  521.     r1 = symlink(cig_string_body(args[1]), cig_string_body(args[0]));
  522.     ret1 = errno_or_false(r1);
  523.     return ret1;
  524.     }
  525.  
  526. scheme_value df_truncate(long nargs, scheme_value *args)
  527. {
  528.     
  529.     scheme_value ret1;
  530.     int r1;
  531.  
  532.     cig_check_nargs(2, nargs, "truncate");
  533.     r1 = truncate(cig_string_body(args[1]), EXTRACT_FIXNUM(args[0]));
  534.     ret1 = errno_or_false(r1);
  535.     return ret1;
  536.     }
  537.  
  538. scheme_value df_ftruncate(long nargs, scheme_value *args)
  539. {
  540.     
  541.     scheme_value ret1;
  542.     int r1;
  543.  
  544.     cig_check_nargs(2, nargs, "ftruncate");
  545.     r1 = ftruncate(EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  546.     ret1 = errno_or_false(r1);
  547.     return ret1;
  548.     }
  549.  
  550. scheme_value df_unlink(long nargs, scheme_value *args)
  551. {
  552.     extern int unlink(const char *);
  553.     scheme_value ret1;
  554.     int r1;
  555.  
  556.     cig_check_nargs(1, nargs, "unlink");
  557.     r1 = unlink(cig_string_body(args[0]));
  558.     ret1 = errno_or_false(r1);
  559.     return ret1;
  560.     }
  561.  
  562. scheme_value df_fsync(long nargs, scheme_value *args)
  563. {
  564.     extern int fsync(int );
  565.     scheme_value ret1;
  566.     int r1;
  567.  
  568.     cig_check_nargs(1, nargs, "fsync");
  569.     r1 = fsync(EXTRACT_FIXNUM(args[0]));
  570.     ret1 = errno_or_false(r1);
  571.     return ret1;
  572.     }
  573.  
  574. scheme_value df_sync(long nargs, scheme_value *args)
  575. {
  576.     
  577.  
  578.     cig_check_nargs(0, nargs, "sync");
  579.     sync();
  580.     return SCHFALSE;
  581.     }
  582.  
  583. scheme_value df_close(long nargs, scheme_value *args)
  584. {
  585.     extern int close(int );
  586.     scheme_value ret1;
  587.     int r1;
  588.  
  589.     cig_check_nargs(1, nargs, "close");
  590.     r1 = close(EXTRACT_FIXNUM(args[0]));
  591.     ret1 = errno_or_false(r1);
  592.     return ret1;
  593.     }
  594.  
  595. scheme_value df_dup(long nargs, scheme_value *args)
  596. {
  597.     extern int dup(int );
  598.     scheme_value ret1;
  599.     int r1;
  600.  
  601.     cig_check_nargs(2, nargs, "dup");
  602.     r1 = dup(EXTRACT_FIXNUM(args[1]));
  603.     ret1 = errno_or_false(r1);
  604.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  605.     return ret1;
  606.     }
  607.  
  608. scheme_value df_dup2(long nargs, scheme_value *args)
  609. {
  610.     extern int dup2(int , int );
  611.     scheme_value ret1;
  612.     int r1;
  613.  
  614.     cig_check_nargs(3, nargs, "dup2");
  615.     r1 = dup2(EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]));
  616.     ret1 = errno_or_false(r1);
  617.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  618.     return ret1;
  619.     }
  620.  
  621. scheme_value df_lseek(long nargs, scheme_value *args)
  622. {
  623.     extern off_t lseek(int , off_t , int );
  624.     scheme_value ret1;
  625.     off_t r1;
  626.  
  627.     cig_check_nargs(4, nargs, "lseek");
  628.     r1 = lseek(EXTRACT_FIXNUM(args[3]), EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]));
  629.     ret1 = errno_or_false(r1);
  630.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  631.     return ret1;
  632.     }
  633.  
  634. scheme_value df_char_ready_fdes(long nargs, scheme_value *args)
  635. {
  636.     extern scheme_value char_ready_fdes(int );
  637.     scheme_value ret1;
  638.     scheme_value r1;
  639.  
  640.     cig_check_nargs(1, nargs, "char_ready_fdes");
  641.     r1 = char_ready_fdes(EXTRACT_FIXNUM(args[0]));
  642.     ret1 = r1;
  643.     return ret1;
  644.     }
  645.  
  646. scheme_value df_open(long nargs, scheme_value *args)
  647. {
  648.     
  649.     scheme_value ret1;
  650.     int r1;
  651.  
  652.     cig_check_nargs(4, nargs, "open");
  653.     r1 = open(cig_string_body(args[3]), EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]));
  654.     ret1 = errno_or_false(r1);
  655.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  656.     return ret1;
  657.     }
  658.  
  659. scheme_value df_scheme_pipe(long nargs, scheme_value *args)
  660. {
  661.     extern int scheme_pipe(int *, int *);
  662.     scheme_value ret1;
  663.     int r1;
  664.     int r2;
  665.     int r3;
  666.  
  667.     cig_check_nargs(1, nargs, "scheme_pipe");
  668.     r1 = scheme_pipe(&r2, &r3);
  669.     ret1 = False_on_zero(r1);
  670.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r2);
  671.     VECTOR_REF(*args,1) = ENTER_FIXNUM(r3);
  672.     return ret1;
  673.     }
  674.  
  675. scheme_value df_read_fdes_char(long nargs, scheme_value *args)
  676. {
  677.     extern scheme_value read_fdes_char(int );
  678.     scheme_value ret1;
  679.     scheme_value r1;
  680.  
  681.     cig_check_nargs(1, nargs, "read_fdes_char");
  682.     r1 = read_fdes_char(EXTRACT_FIXNUM(args[0]));
  683.     ret1 = r1;
  684.     return ret1;
  685.     }
  686.  
  687. scheme_value df_write_fdes_char(long nargs, scheme_value *args)
  688. {
  689.     extern int write_fdes_char(char , int );
  690.     scheme_value ret1;
  691.     int r1;
  692.  
  693.     cig_check_nargs(2, nargs, "write_fdes_char");
  694.     r1 = write_fdes_char(EXTRACT_CHAR(args[1]), EXTRACT_FIXNUM(args[0]));
  695.     ret1 = errno_or_false(r1);
  696.     return ret1;
  697.     }
  698.  
  699. scheme_value df_read_fdes_substring(long nargs, scheme_value *args)
  700. {
  701.     extern int read_fdes_substring(scheme_value , int , int , int );
  702.     scheme_value ret1;
  703.     int r1;
  704.  
  705.     cig_check_nargs(5, nargs, "read_fdes_substring");
  706.     r1 = read_fdes_substring(args[4], EXTRACT_FIXNUM(args[3]), EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]));
  707.     ret1 = errno_or_false(r1);
  708.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  709.     return ret1;
  710.     }
  711.  
  712. scheme_value df_write_fdes_substring(long nargs, scheme_value *args)
  713. {
  714.     extern int write_fdes_substring(scheme_value , int , int , int );
  715.     scheme_value ret1;
  716.     int r1;
  717.  
  718.     cig_check_nargs(5, nargs, "write_fdes_substring");
  719.     r1 = write_fdes_substring(args[4], EXTRACT_FIXNUM(args[3]), EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]));
  720.     ret1 = errno_or_false(r1);
  721.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  722.     return ret1;
  723.     }
  724.  
  725. scheme_value df_kill(long nargs, scheme_value *args)
  726. {
  727.     extern int kill(pid_t , int );
  728.     scheme_value ret1;
  729.     int r1;
  730.  
  731.     cig_check_nargs(2, nargs, "kill");
  732.     r1 = kill(EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  733.     ret1 = errno_or_false(r1);
  734.     return ret1;
  735.     }
  736.  
  737. scheme_value df_pause(long nargs, scheme_value *args)
  738. {
  739.     
  740.  
  741.     cig_check_nargs(0, nargs, "pause");
  742.     pause();
  743.     return SCHFALSE;
  744.     }
  745.  
  746. scheme_value df_alarm(long nargs, scheme_value *args)
  747. {
  748.     extern unsigned int alarm(unsigned int );
  749.     scheme_value ret1;
  750.     unsigned int r1;
  751.  
  752.     cig_check_nargs(1, nargs, "alarm");
  753.     r1 = alarm(EXTRACT_FIXNUM(args[0]));
  754.     ret1 = ENTER_FIXNUM(r1);
  755.     return ret1;
  756.     }
  757.  
  758. scheme_value df_user_info_uid(long nargs, scheme_value *args)
  759. {
  760.     extern int user_info_uid(uid_t , char **, gid_t  *, char **, char **);
  761.     scheme_value ret1;
  762.     int r1;
  763.     char *r2;
  764.     gid_t  r3;
  765.     char *r4;
  766.     char *r5;
  767.  
  768.     cig_check_nargs(2, nargs, "user_info_uid");
  769.     r1 = user_info_uid(EXTRACT_FIXNUM(args[1]), &r2, &r3, &r4, &r5);
  770.     ret1 = ENTER_BOOLEAN(r1);
  771.     {AlienVal(CAR(VECTOR_REF(*args,0))) = (long) r2; CDR(VECTOR_REF(*args,0)) = strlen_or_false(r2);}
  772.     VECTOR_REF(*args,1) = ENTER_FIXNUM(r3);
  773.     {AlienVal(CAR(VECTOR_REF(*args,2))) = (long) r4; CDR(VECTOR_REF(*args,2)) = strlen_or_false(r4);}
  774.     {AlienVal(CAR(VECTOR_REF(*args,3))) = (long) r5; CDR(VECTOR_REF(*args,3)) = strlen_or_false(r5);}
  775.     return ret1;
  776.     }
  777.  
  778. scheme_value df_user_info_name(long nargs, scheme_value *args)
  779. {
  780.     extern int user_info_name(const char *, uid_t *, gid_t  *, char **, char **);
  781.     scheme_value ret1;
  782.     int r1;
  783.     uid_t r2;
  784.     gid_t  r3;
  785.     char *r4;
  786.     char *r5;
  787.  
  788.     cig_check_nargs(2, nargs, "user_info_name");
  789.     r1 = user_info_name(cig_string_body(args[1]), &r2, &r3, &r4, &r5);
  790.     ret1 = ENTER_BOOLEAN(r1);
  791.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r2);
  792.     VECTOR_REF(*args,1) = ENTER_FIXNUM(r3);
  793.     {AlienVal(CAR(VECTOR_REF(*args,2))) = (long) r4; CDR(VECTOR_REF(*args,2)) = strlen_or_false(r4);}
  794.     {AlienVal(CAR(VECTOR_REF(*args,3))) = (long) r5; CDR(VECTOR_REF(*args,3)) = strlen_or_false(r5);}
  795.     return ret1;
  796.     }
  797.  
  798. scheme_value df_group_info_gid(long nargs, scheme_value *args)
  799. {
  800.     extern int group_info_gid(int , char **, char** *, int *);
  801.     scheme_value ret1;
  802.     int r1;
  803.     char *r2;
  804.     char** r3;
  805.     int r4;
  806.  
  807.     cig_check_nargs(2, nargs, "group_info_gid");
  808.     r1 = group_info_gid(EXTRACT_FIXNUM(args[1]), &r2, &r3, &r4);
  809.     ret1 = ENTER_BOOLEAN(r1);
  810.     {AlienVal(CAR(VECTOR_REF(*args,0))) = (long) r2; CDR(VECTOR_REF(*args,0)) = strlen_or_false(r2);}
  811.     AlienVal(VECTOR_REF(*args,1)) = (long) r3;
  812.     VECTOR_REF(*args,2) = ENTER_FIXNUM(r4);
  813.     return ret1;
  814.     }
  815.  
  816. scheme_value df_group_info_name(long nargs, scheme_value *args)
  817. {
  818.     extern int group_info_name(const char *, int *, char** *, int *);
  819.     scheme_value ret1;
  820.     int r1;
  821.     int r2;
  822.     char** r3;
  823.     int r4;
  824.  
  825.     cig_check_nargs(2, nargs, "group_info_name");
  826.     r1 = group_info_name(cig_string_body(args[1]), &r2, &r3, &r4);
  827.     ret1 = ENTER_BOOLEAN(r1);
  828.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r2);
  829.     AlienVal(VECTOR_REF(*args,1)) = (long) r3;
  830.     VECTOR_REF(*args,2) = ENTER_FIXNUM(r4);
  831.     return ret1;
  832.     }
  833.  
  834. scheme_value df_open_dir(long nargs, scheme_value *args)
  835. {
  836.     extern int open_dir(const char *, char** *, int *);
  837.     scheme_value ret1;
  838.     int r1;
  839.     char** r2;
  840.     int r3;
  841.  
  842.     cig_check_nargs(2, nargs, "open_dir");
  843.     r1 = open_dir(cig_string_body(args[1]), &r2, &r3);
  844.     ret1 = False_on_zero(r1);
  845.     AlienVal(VECTOR_REF(*args,0)) = (long) r2;
  846.     VECTOR_REF(*args,1) = ENTER_FIXNUM(r3);
  847.     return ret1;
  848.     }
  849.  
  850. scheme_value df_scm_sort_filevec(long nargs, scheme_value *args)
  851. {
  852.     extern void scm_sort_filevec(const char** , int );
  853.  
  854.     cig_check_nargs(2, nargs, "scm_sort_filevec");
  855.     scm_sort_filevec((const char** )AlienVal(args[1]), EXTRACT_FIXNUM(args[0]));
  856.     return SCHFALSE;
  857.     }
  858.  
  859. scheme_value df_scm_envvec(long nargs, scheme_value *args)
  860. {
  861.     extern char** scm_envvec(int *);
  862.     scheme_value ret1;
  863.     char** r1;
  864.     int r2;
  865.  
  866.     cig_check_nargs(1, nargs, "scm_envvec");
  867.     r1 = scm_envvec(&r2);
  868.     ret1 = VECTOR_REF(*args,0);
  869.     AlienVal(ret1) = (long) r1;
  870.     VECTOR_REF(*args,1) = ENTER_FIXNUM(r2);
  871.     return ret1;
  872.     }
  873.  
  874. scheme_value df_install_env(long nargs, scheme_value *args)
  875. {
  876.     extern int install_env(scheme_value );
  877.     scheme_value ret1;
  878.     int r1;
  879.  
  880.     cig_check_nargs(1, nargs, "install_env");
  881.     r1 = install_env(args[0]);
  882.     ret1 = errno_or_false(r1);
  883.     return ret1;
  884.     }
  885.  
  886. scheme_value df_getenv(long nargs, scheme_value *args)
  887. {
  888.     extern char *getenv(const char *);
  889.     scheme_value ret1;
  890.     char *r1;
  891.  
  892.     cig_check_nargs(2, nargs, "getenv");
  893.     r1 = getenv(cig_string_body(args[1]));
  894.     ret1 = VECTOR_REF(*args,0);
  895.     {AlienVal(CAR(ret1)) = (long) r1; CDR(ret1) = strlen_or_false(r1);}
  896.     return ret1;
  897.     }
  898.  
  899. #define errno_on_nonzero_or_false(x) ((x) ? ENTER_FIXNUM(errno) : SCHFALSE)
  900.  
  901. scheme_value df_putenv(long nargs, scheme_value *args)
  902. {
  903.     
  904.     scheme_value ret1;
  905.     int r1;
  906.  
  907.     cig_check_nargs(1, nargs, "putenv");
  908.     r1 = putenv(scheme2c_strcpy(args[0]));
  909.     ret1 = errno_on_nonzero_or_false(r1);
  910.     return ret1;
  911.     }
  912.  
  913. scheme_value df_delete_env(long nargs, scheme_value *args)
  914. {
  915.     extern void delete_env(const char *);
  916.  
  917.     cig_check_nargs(1, nargs, "delete_env");
  918.     delete_env(cig_string_body(args[0]));
  919.     return SCHFALSE;
  920.     }
  921.  
  922. scheme_value df_close_fdport(long nargs, scheme_value *args)
  923. {
  924.     extern int close_fdport(scheme_value );
  925.     scheme_value ret1;
  926.     int r1;
  927.  
  928.     cig_check_nargs(1, nargs, "close_fdport");
  929.     r1 = close_fdport(args[0]);
  930.     ret1 = False_on_zero(r1);
  931.     return ret1;
  932.     }
  933.  
  934. scheme_value df_fdport_getchar(long nargs, scheme_value *args)
  935. {
  936.     extern scheme_value fdport_getchar(scheme_value );
  937.     scheme_value ret1;
  938.     scheme_value r1;
  939.  
  940.     cig_check_nargs(1, nargs, "fdport_getchar");
  941.     r1 = fdport_getchar(args[0]);
  942.     ret1 = r1;
  943.     return ret1;
  944.     }
  945.  
  946. scheme_value df_fdport_char_readyp(long nargs, scheme_value *args)
  947. {
  948.     extern scheme_value fdport_char_readyp(scheme_value );
  949.     scheme_value ret1;
  950.     scheme_value r1;
  951.  
  952.     cig_check_nargs(1, nargs, "fdport_char_readyp");
  953.     r1 = fdport_char_readyp(args[0]);
  954.     ret1 = r1;
  955.     return ret1;
  956.     }
  957.  
  958. scheme_value df_fdport_putchar(long nargs, scheme_value *args)
  959. {
  960.     extern int fdport_putchar(scheme_value , char );
  961.     scheme_value ret1;
  962.     int r1;
  963.  
  964.     cig_check_nargs(2, nargs, "fdport_putchar");
  965.     r1 = fdport_putchar(args[1], EXTRACT_CHAR(args[0]));
  966.     ret1 = False_on_zero(r1);
  967.     return ret1;
  968.     }
  969.  
  970. scheme_value df_flush_fdport(long nargs, scheme_value *args)
  971. {
  972.     extern int flush_fdport(scheme_value );
  973.     scheme_value ret1;
  974.     int r1;
  975.  
  976.     cig_check_nargs(1, nargs, "flush_fdport");
  977.     r1 = flush_fdport(args[0]);
  978.     ret1 = False_on_zero(r1);
  979.     return ret1;
  980.     }
  981.  
  982. scheme_value df_flush_all_ports(long nargs, scheme_value *args)
  983. {
  984.     extern int flush_all_ports(void);
  985.     scheme_value ret1;
  986.     int r1;
  987.  
  988.     cig_check_nargs(0, nargs, "flush_all_ports");
  989.     r1 = flush_all_ports();
  990.     ret1 = errno_or_false(r1);
  991.     return ret1;
  992.     }
  993.  
  994. scheme_value df_seek_fdport(long nargs, scheme_value *args)
  995. {
  996.     extern int seek_fdport(scheme_value , off_t , int , int *);
  997.     scheme_value ret1;
  998.     int r1;
  999.     int r2;
  1000.  
  1001.     cig_check_nargs(4, nargs, "seek_fdport");
  1002.     r1 = seek_fdport(args[3], EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]), &r2);
  1003.     ret1 = False_on_zero(r1);
  1004.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r2);
  1005.     return ret1;
  1006.     }
  1007.  
  1008. scheme_value df_tell_fdport(long nargs, scheme_value *args)
  1009. {
  1010.     extern int tell_fdport(scheme_value , int *);
  1011.     scheme_value ret1;
  1012.     int r1;
  1013.     int r2;
  1014.  
  1015.     cig_check_nargs(2, nargs, "tell_fdport");
  1016.     r1 = tell_fdport(args[1], &r2);
  1017.     ret1 = False_on_zero(r1);
  1018.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r2);
  1019.     return ret1;
  1020.     }
  1021.  
  1022. scheme_value df_set_fdbuf(long nargs, scheme_value *args)
  1023. {
  1024.     extern int set_fdbuf(scheme_value , int , int );
  1025.     scheme_value ret1;
  1026.     int r1;
  1027.  
  1028.     cig_check_nargs(3, nargs, "set_fdbuf");
  1029.     r1 = set_fdbuf(args[2], EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  1030.     ret1 = False_on_zero(r1);
  1031.     return ret1;
  1032.     }
  1033.  
  1034. scheme_value df_init_fdports(long nargs, scheme_value *args)
  1035. {
  1036.     extern void init_fdports(void);
  1037.  
  1038.     cig_check_nargs(0, nargs, "init_fdports");
  1039.     init_fdports();
  1040.     return SCHFALSE;
  1041.     }
  1042.  
  1043. scheme_value df_cloexec_unrevealed(long nargs, scheme_value *args)
  1044. {
  1045.     extern void cloexec_unrevealed(void);
  1046.  
  1047.     cig_check_nargs(0, nargs, "cloexec_unrevealed");
  1048.     cloexec_unrevealed();
  1049.     return SCHFALSE;
  1050.     }
  1051.  
  1052. scheme_value df_install_port(long nargs, scheme_value *args)
  1053. {
  1054.     extern int install_port(int , scheme_value );
  1055.     scheme_value ret1;
  1056.     int r1;
  1057.  
  1058.     cig_check_nargs(2, nargs, "install_port");
  1059.     r1 = install_port(EXTRACT_FIXNUM(args[1]), args[0]);
  1060.     ret1 = False_on_zero(r1);
  1061.     return ret1;
  1062.     }
  1063.  
  1064. scheme_value df_maybe_fdes2port(long nargs, scheme_value *args)
  1065. {
  1066.     extern scheme_value maybe_fdes2port(int );
  1067.     scheme_value ret1;
  1068.     scheme_value r1;
  1069.  
  1070.     cig_check_nargs(1, nargs, "maybe_fdes2port");
  1071.     r1 = maybe_fdes2port(EXTRACT_FIXNUM(args[0]));
  1072.     ret1 = r1;
  1073.     return ret1;
  1074.     }
  1075.  
  1076. scheme_value df_move_fdport(long nargs, scheme_value *args)
  1077. {
  1078.     extern int move_fdport(int , scheme_value , int );
  1079.     scheme_value ret1;
  1080.     int r1;
  1081.  
  1082.     cig_check_nargs(3, nargs, "move_fdport");
  1083.     r1 = move_fdport(EXTRACT_FIXNUM(args[2]), args[1], EXTRACT_FIXNUM(args[0]));
  1084.     ret1 = ENTER_BOOLEAN(r1);
  1085.     return ret1;
  1086.     }
  1087.  
  1088. scheme_value df_read_fdport_substring(long nargs, scheme_value *args)
  1089. {
  1090.     extern int read_fdport_substring(scheme_value , int , int , scheme_value );
  1091.     scheme_value ret1;
  1092.     int r1;
  1093.  
  1094.     cig_check_nargs(5, nargs, "read_fdport_substring");
  1095.     r1 = read_fdport_substring(args[4], EXTRACT_FIXNUM(args[3]), EXTRACT_FIXNUM(args[2]), args[1]);
  1096.     ret1 = errno_or_false(r1);
  1097.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  1098.     return ret1;
  1099.     }
  1100.  
  1101. scheme_value df_write_fdport_substring(long nargs, scheme_value *args)
  1102. {
  1103.     extern int write_fdport_substring(scheme_value , int , int , scheme_value );
  1104.     scheme_value ret1;
  1105.     int r1;
  1106.  
  1107.     cig_check_nargs(5, nargs, "write_fdport_substring");
  1108.     r1 = write_fdport_substring(args[4], EXTRACT_FIXNUM(args[3]), EXTRACT_FIXNUM(args[2]), args[1]);
  1109.     ret1 = errno_or_false(r1);
  1110.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  1111.     return ret1;
  1112.     }
  1113.  
  1114. scheme_value df_fcntl_read(long nargs, scheme_value *args)
  1115. {
  1116.     extern int fcntl_read(int , int );
  1117.     scheme_value ret1;
  1118.     int r1;
  1119.  
  1120.     cig_check_nargs(3, nargs, "fcntl_read");
  1121.     r1 = fcntl_read(EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]));
  1122.     ret1 = errno_or_false(r1);
  1123.     VECTOR_REF(*args,0) = ENTER_FIXNUM(r1);
  1124.     return ret1;
  1125.     }
  1126.  
  1127. scheme_value df_fcntl_write(long nargs, scheme_value *args)
  1128. {
  1129.     extern int fcntl_write(int , int , int );
  1130.     scheme_value ret1;
  1131.     int r1;
  1132.  
  1133.     cig_check_nargs(3, nargs, "fcntl_write");
  1134.     r1 = fcntl_write(EXTRACT_FIXNUM(args[2]), EXTRACT_FIXNUM(args[1]), EXTRACT_FIXNUM(args[0]));
  1135.     ret1 = errno_or_false(r1);
  1136.     return ret1;
  1137.     }
  1138.  
  1139. scheme_value df_sleep(long nargs, scheme_value *args)
  1140. {
  1141.     extern unsigned int sleep(unsigned int );
  1142.     scheme_value ret1;
  1143.     unsigned int r1;
  1144.  
  1145.     cig_check_nargs(1, nargs, "sleep");
  1146.     r1 = sleep(EXTRACT_FIXNUM(args[0]));
  1147.     ret1 = ENTER_FIXNUM(r1);
  1148.     return ret1;
  1149.     }
  1150.  
  1151. scheme_value df_scm_gethostname(long nargs, scheme_value *args)
  1152. {
  1153.     extern char *scm_gethostname(void);
  1154.     scheme_value ret1;
  1155.     char *r1;
  1156.  
  1157.     cig_check_nargs(1, nargs, "scm_gethostname");
  1158.     r1 = scm_gethostname();
  1159.     ret1 = VECTOR_REF(*args,0);
  1160.     {AlienVal(CAR(ret1)) = (long) r1; CDR(ret1) = strlen_or_false(r1);}
  1161.     return ret1;
  1162.     }
  1163.  
  1164. scheme_value df_errno_msg(long nargs, scheme_value *args)
  1165. {
  1166.     extern char *errno_msg(int );
  1167.     scheme_value ret1;
  1168.     char *r1;
  1169.  
  1170.     cig_check_nargs(2, nargs, "errno_msg");
  1171.     r1 = errno_msg(EXTRACT_FIXNUM(args[1]));
  1172.     ret1 = VECTOR_REF(*args,0);
  1173.     {AlienVal(CAR(ret1)) = (long) r1; CDR(ret1) = strlen_or_false(r1);}
  1174.     return ret1;
  1175.     }
  1176.  
  1177.